package org.jimmy.tang.concurrent.exchanger;

import java.util.concurrent.Exchanger;

/**
 * @author jimmy
 * 
 */
public class FillAndEmpty {

    static Exchanger<Cup> exchanger = new Exchanger<Cup>();
    static Cup emptyCup = new Cup(0);
    static Cup fullCup = new Cup(100);

    public static void main(String[] args) {
        new Thread(new Waiter(3)).start();
        new Thread(new Customer(6)).start();
    }

    /**
     * 服务员
     * 
     * @author Administrator
     * 
     */
    static class Waiter implements Runnable {

        int addSpeed = 1;

        public Waiter(int addSpeed) {
            this.addSpeed = addSpeed;
        }

        @Override
        public void run() {
            while (emptyCup != null) {
                // 如果发现杯子中的水没有满，则往杯中加水。
                try {
                    if (emptyCup.isFull()) {// 当emptyCup为装满水时并且fullCup为被喝完水时，进行交换。
                        // 当Waiter把杯子水装满后，与Customer交换杯子。
                        // exchange(emptyCup)中参数的emptyCup是waiter装满水后的，把装满水后的emptyCup参数传递给Cutomer线程。
                        // 并且返回Cutomer线程中fullCup给Waiter的emptyCup，这样就达到了交换效果。
                        emptyCup = exchanger.exchange(emptyCup);
                        System.out.println("Waiter: " + emptyCup.capacity);
                    } else {
                        emptyCup.addWaterToCup(3);
                        System.out.println("Waiter add " + addSpeed
                                + " and current capacity is "
                                + emptyCup.capacity);
                        Thread.sleep((long) (Math.max(500, Math.random() * 2000)));
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 消费者
     * 
     * @author Administrator
     * 
     */
    static class Customer implements Runnable {

        int drinkSpeed = 1;

        public Customer(int drinkSpeed) {
            this.drinkSpeed = drinkSpeed;
        }

        @Override
        public void run() {
            while (fullCup != null) {
                // 如果发现杯子中的水没有满，则往杯中加水。
                try {
                    if (fullCup.isEmpty()) {
                        // 水满后则交换子中的水
                        fullCup = exchanger.exchange(fullCup);
                        System.out.println("Customer: " + fullCup.capacity);
                    } else {
                        fullCup.drinkFormCup(drinkSpeed);
                        System.out.println("Customer drinked " + drinkSpeed
                                + " and current capacity is "
                                + fullCup.capacity);
                        Thread.sleep((long) (Math.max(500, Math.random() * 2000)));
                    }

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    static class Cup {

        private int capacity = 0;

        public Cup(int capacity) {
            this.capacity = capacity;
        }

        public void addWaterToCup(int i) {
            capacity += i;
            capacity = capacity > 100 ? 100 : capacity;
        }

        public void drinkFormCup(int i) {
            capacity -= i;
            capacity = capacity < 0 ? 0 : capacity;
        }

        public boolean isFull() {
            return capacity == 100 ? true : false;
        }

        public boolean isEmpty() {
            return capacity == 0 ? true : false;
        }
    }
}
